home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 22 / Cream of the Crop 22.iso / os2 / ext2_200.zip / EXT2_SRC.ZIP / 32BITS / EXT2-OS2 / FSD32 / FS32_PAT.C < prev    next >
C/C++ Source or Header  |  1996-09-21  |  13KB  |  251 lines
  1. //
  2. // $Header: D:/32bits/ext2-os2/fsd32/RCS/fs32_pathinfo.c,v 1.1 1996/09/21 22:25:38 Willm Exp Willm $
  3. //
  4.  
  5. // 32 bits Linux ext2 file system driver for OS/2 WARP - Allows OS/2 to
  6. // access your Linux ext2fs partitions as normal drive letters.
  7. // Copyright (C) 1995, 1996 Matthieu WILLM
  8. //
  9. // This program is free software; you can redistribute it and/or modify
  10. // it under the terms of the GNU General Public License as published by
  11. // the Free Software Foundation; either version 2 of the License, or
  12. // (at your option) any later version.
  13. //
  14. // This program is distributed in the hope that it will be useful,
  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17. // GNU General Public License for more details.
  18. //
  19. // You should have received a copy of the GNU General Public License
  20. // along with this program; if not, write to the Free Software
  21. // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22. #ifdef __IBMC__
  23. #pragma strings(readonly)
  24. #endif
  25.  
  26.  
  27. #define INCL_DOS
  28. #define INCL_DOSERRORS
  29. #define INCL_NOPMAPI
  30. #include <os2.h>
  31.  
  32. #include <string.h>
  33.  
  34. #include <os2/types.h>
  35. #include <os2/StackToFlat.h>
  36. #include <linux/fs.h>
  37. #include <os2/os2proto.h>
  38. #include <os2/fsd32.h>
  39. #include <os2/DevHlp32.h>
  40. #include <os2/log.h>
  41. #include <os2/trace.h>
  42. #include <os2/errors.h>
  43. #include <os2/files.h>
  44. #include <os2/volume.h>
  45. #include <linux/fs_proto.h>
  46. #include <linux/stat.h>
  47. #include <os2/filefind.h>
  48.  
  49. #define THISFILE FILE_TEST_C    //obsolete
  50.  
  51. /*
  52.  * struct fs32_pathinfo_parms {
  53.  *     unsigned short cbData;
  54.  *     PTR16          pData;
  55.  *     unsigned short level;
  56.  *     unsigned short iCurDirEnd;
  57.  *     PTR16          pName;
  58.  *     PTR16          pcdfsd;
  59.  *     PTR16          pcdfsi;
  60.  *     unsigned short flag;
  61.  * };
  62.  */
  63. int FS32ENTRY fs32_pathinfo(struct fs32_pathinfo_parms *parms) {
  64.     char           *pData;
  65.     char           *pName;
  66.     struct cdfsi32 *pcdfsi;
  67. //    union  cdfsd32 *pcdfsd;
  68.     int             rc;
  69.     int      rc2, rc3;
  70.     struct super_block *p_volume;
  71.     struct file        *p_file;
  72.     UINT32   len, openmode = 0;
  73.     PEAOP16    peaop;
  74.     PFEALIST   fpFEAList;
  75.     char          lock[12];
  76.     unsigned long PgCount;
  77.  
  78.  
  79.     parms = __StackToFlat(parms);
  80.  
  81.     if ((rc = DevHlp32_VirtToLin(parms->pcdfsi, __StackToFlat(&pcdfsi))) == NO_ERROR) {
  82. //        if ((rc = DevHlp32_VirtToLin(parms->pcdfsd, __StackToFlat(&pcdfsd))) == NO_ERROR) {
  83.             if ((rc = DevHlp32_VirtToLin(parms->pData, __StackToFlat(&pData))) == NO_ERROR) {
  84.                 if ((rc = DevHlp32_VirtToLin(parms->pName, __StackToFlat(&pName))) == NO_ERROR) {
  85.  
  86.                     //
  87.                     // Verify the level is valid
  88.                     //
  89.                     if ((parms->level == FIL_STANDARD)         ||
  90.                         (parms->level == FIL_QUERYEASIZE)      ||
  91.                         (parms->level == FIL_QUERYEASFROMLIST) ||
  92.                         (parms->level == FIL_QUERYALLEAS)      ||  // Undocumented level - similar to level 3 but for full EA set
  93.                         (parms->level == FIL_LEVEL7)) {
  94.  
  95.                         openmode = (is_case_retensive() ? OPENMODE_DOSBOX : 0);
  96.  
  97.                         //
  98.                         // Retrieves the superblock from psffsi
  99.                         //
  100.                         if ((p_volume = getvolume(pcdfsi->cdi_hVPB)) != 0) {
  101.  
  102.                             switch(parms->flag) {
  103.                                 case PI_RETRIEVE :
  104.                                     if (trace_FS_PATHINFO) {
  105.                                         kernel_printf("FS_PATHINFO - PI_RETRIEVE - lvl = %u - %s", parms->level, pName);
  106.                                     }
  107.  
  108.  
  109.                                     switch(parms->level) {
  110.                                         case FIL_LEVEL7 :
  111.                                             if (strlen(pName) < parms->cbData) {
  112.                                                 if ((rc = DevHlp32_VMLock(VMDHL_LONG | VMDHL_VERIFY, pData, parms->cbData, (void *)-1, __StackToFlat(lock), __StackToFlat(&PgCount))) == NO_ERROR) {
  113.                                                     memcpy(pData, pName,strlen(pName) + 1);
  114.                                                     rc = NO_ERROR;
  115.                                                     if ((rc2 = DevHlp32_VMUnlock(__StackToFlat(lock))) == NO_ERROR) {
  116.                                                         /* Nothing else to do */
  117.                                                     } else {
  118.                                                         kernel_printf("FS_FILEINFO : VMUnlock() returned %d", rc2);
  119.                                                         rc = rc2;
  120.                                                     } /* VMUnlock failed */
  121.                                                 }
  122.                                             } else {
  123.                                                 rc = ERROR_BUFFER_OVERFLOW;
  124.                                             }
  125.                                             break;
  126.  
  127.                                         default :
  128.                                             if ((p_file = _open_by_name(p_volume, pName, openmode | OPENMODE_READONLY)) != 0) {
  129.                                                 if ((parms->level == FIL_QUERYEASFROMLIST) ||
  130.                                                     (parms->level == FIL_QUERYALLEAS)) {
  131.                                                     peaop  = (PEAOP16)pData;
  132.                                                     if ((rc = DevHlp32_VirtToLin(peaop->fpFEAList, __StackToFlat(&fpFEAList))) == NO_ERROR) {
  133.                                                         if ((rc = DevHlp32_VMLock(VMDHL_LONG | VMDHL_VERIFY | VMDHL_WRITE, pData, 4, (void *)-1, __StackToFlat(lock), __StackToFlat(&PgCount))) == NO_ERROR) {
  134.                                                             fpFEAList->cbList = 4;       // NO EAS for ext2
  135.                                                             rc = NO_ERROR;
  136.                                                             if ((rc2 = DevHlp32_VMUnlock(__StackToFlat(lock))) == NO_ERROR) {
  137.                                                                 /* Nothing else to do */
  138.                                                             } else {
  139.                                                                 kernel_printf("FS_FILEINFO : VMUnlock() returned %d", rc2);
  140.                                                                 rc = rc2;
  141.                                                             } /* VMUnlock failed */
  142.                                                         }
  143.                                                     }
  144.                                                 } else {
  145.                                                     if ((rc = DevHlp32_VMLock(VMDHL_LONG | VMDHL_VERIFY | VMDHL_WRITE, pData, parms->cbData, (void *)-1, __StackToFlat(lock), __StackToFlat(&PgCount))) == NO_ERROR) {
  146.                                                         if ((rc = ino_to_fileinfo(
  147.                                                                                   p_file->f_inode,
  148.                                                                                   pData,
  149.                                                                                   parms->cbData,
  150.                                                                                   __StackToFlat(&len),
  151.                                                                                   parms->level,
  152.                                                                                   0,
  153.                                                                                   0,
  154.                                                                                   0,
  155.                                                                                   0, TYPEOP_FILEINFO)) == NO_ERROR) {
  156.                                                         } else {
  157.                                                             fs_log("FS_PATHINFO() - ino_to_fileinfo()");
  158.                                                         }
  159.                                                         if ((rc2 = DevHlp32_VMUnlock(__StackToFlat(lock))) == NO_ERROR) {
  160.                                                             /* Nothing else to do */
  161.                                                         } else {
  162.                                                             kernel_printf("FS_FILEINFO : VMUnlock() returned %d", rc2);
  163.                                                             rc = rc2;
  164.                                                         } /* VMUnlock failed */
  165.  
  166.                                                     }
  167.                                                 }
  168.                                                 if ((rc2 = vfs_close(p_file)) == NO_ERROR) {
  169.                                                 } else {
  170.                                                     fs_err(FUNC_FS_PATHINFO, FUNC_CLOSE, rc, THISFILE, __LINE__);
  171.                                                     rc2 = rc;
  172.                                                 }
  173.                                             } else {
  174. #ifdef FS_TRACE
  175.                                                 fs_err(FUNC_FS_PATHINFO, FUNC_OPEN_BY_NAME, ERROR_PATH_NOT_FOUND, THISFILE, __LINE__);
  176. #endif
  177.                                                 rc = ERROR_FILE_NOT_FOUND;
  178.                                             }
  179.                                             break;
  180.                                     } /* end switch */
  181.                                     break;
  182.  
  183.         case PI_SET :
  184.         case PI_SET + 0x10 :
  185.             if (trace_FS_PATHINFO) {
  186.                 kernel_printf("FS_PATHINFO - PI_SET - %s", pName);
  187.             }
  188.             rc = NO_ERROR;
  189.             if (Read_Write) {
  190.                 if ((p_file = _open_by_name(p_volume, pName, openmode | OPENMODE_READONLY)) != 0) {
  191.                     if ((rc = DevHlp32_VMLock(VMDHL_LONG | VMDHL_VERIFY, pData, parms->cbData, (void *)-1, __StackToFlat(lock), __StackToFlat(&PgCount))) == NO_ERROR) {
  192.                         if ((rc = fileinfo_to_ino(pData, p_file->f_inode, parms->level, parms->cbData, 0)) == NO_ERROR) {
  193.                             /*
  194.                              * Nothing else to do
  195.                              */
  196.                         } else {
  197.                             kernel_printf("fileinfo_to_ino returned %d", rc);
  198.                         }
  199.                         if ((rc2 = DevHlp32_VMUnlock(__StackToFlat(lock))) == NO_ERROR) {
  200.                             /*
  201.                              * Nothing else to do ...
  202.                              */
  203.                         } else {
  204.                             kernel_printf("FS_PATHINFO : VMUnlock() returned %d", rc2);
  205.                             rc = rc2;
  206.                         } /* VMUnlock failed */
  207.                     } else {
  208.                         kernel_printf("FS_PATHINFO : LockUserBuffer() returned %d", rc);
  209.                     }
  210.  
  211.                     if ((rc2 = vfs_close(p_file)) == NO_ERROR) {
  212.                         /*
  213.                          * Nothing else to do.
  214.                          */
  215.                     } else {
  216.                         fs_err(FUNC_FS_PATHINFO, FUNC_CLOSE, rc, THISFILE, __LINE__);
  217.                         rc = rc2;
  218.                     }
  219.                 } else {
  220. #ifdef FS_TRACE
  221.                     fs_err(FUNC_FS_PATHINFO, FUNC_OPEN_BY_NAME, ERROR_PATH_NOT_FOUND, THISFILE, __LINE__);
  222. #endif
  223.                     rc = ERROR_FILE_NOT_FOUND;
  224.                 }
  225.             } else {
  226.                 rc = ERROR_WRITE_PROTECT;
  227.             }
  228.             break;
  229.  
  230.  
  231.         default :
  232.             kernel_printf("FS_PATHINFO( %s ) - unknown flag %d", pName, parms->flag);
  233.             rc = ERROR_INVALID_PARAMETER;
  234.             break;
  235.     } /* end switch */
  236.  
  237.                         } else {
  238.                             rc = ERROR_INVALID_PARAMETER;
  239.                         }
  240.                     } else {
  241.                         kernel_printf("FS_PATHINFO() - invalid level %u", parms->level);
  242.                         rc = ERROR_INVALID_PARAMETER;
  243.                     }
  244.  
  245.                 }
  246.             }
  247. //        }
  248.     }
  249.     return rc;
  250. }
  251.